﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Schedule.Support.Components
{
    public static class PicLibrary16
    {
        #region Image Book
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book_Cached
        {
            get
            {
                if (_Book == null) _Book = Book;
                return _Book;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book { get { return _ImageCreateFrom(_Book_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book_FromFile { get { return _ImageCreateFrom(_Book_string, "book.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book
        /// </summary>
        /// <returns></returns>
        private static string _Book_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1416);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAeNJREFUOMt1k79qVUEQxn/n5N6bEBsVRSySoChI4k2ngoLgCyg+gYUgdj6AD6OIldooiIKFsRO0FgtRtIxF/oDJ2d2Z+Sz2RGO8d2EZWHZ+");
            sb.Append("8327M40krt97sCLpqWADcVkICZCoQX92eKGkrW/vHt0/DTCgXrgjODdeXmzWf24h7SVBhQUK2Nz6xW4SocEp+lUBcHW8vNBcW11g8eQYVQKhqFWjVj9+eJ75uQFXbtzl");
            sb.Append("HwDSkfHKEq8+fmFjYwdFABB7KiQUYnN7hy5l9q/eAs1gNODs+SXOnDiKO0hBhHAXHoGF2O0KT56tTQII9+D7+jajdkjXdZSUsajnxgyD4Yhjh2YJaQIACA/MCyklbl48");
            sb.Append("U+VXdUji4dvPlLkhB/L/KigeeDHMWx6vfSIVw1y4BUbDcDQiW33UiQCzIJdCDlA7SzMcQiuiCSKC7A3ZpwKgmGOdkYpjHhSPPlY4DZgPUExT4EFJhVS82nGRe4i5aBuw");
            sb.Append("7FMesbdQcgVYiGyBe1BClOLM0FLmNdlCSGRzLBmpBCUCN1HCKaXvBTnFYtovUC9lrxYiMAvMhFnthVYNbkKIiPjxnwXalguXVlHT4C7MRfRRfTfmbEiQurR2EPDm9cv3");
            sb.Append("t+vk7et/BAcmE/Hi64fnt/YAvwF8+tWWuzrHCwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNi0wNzowMP139XUAAAAldEVYdGRhdGU6Y3JlYXRl");
            sb.Append("ADIwMTAtMDEtMTFUMDY6NTM6MDUtMDc6MDCnZrnaAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUzOjA1LTA3OjAw1jsBZgAAAGJ0RVh0TGljZW5zZQBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAA");
            sb.Append("JXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIxOjQ5OjE2LTA3OjAwmOFBgwAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJj");
            sb.Append("ZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAzdEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVO");
            sb.Append("RK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book_Reset()
        {
            _Book = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book = null;
        #endregion
        #region Image Book1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1_Cached
        {
            get
            {
                if (_Book1 == null) _Book1 = Book1;
                return _Book1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1 { get { return _ImageCreateFrom(_Book1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book1.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1_FromFile { get { return _ImageCreateFrom(_Book1_string, "book1.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book1
        /// </summary>
        /// <returns></returns>
        private static string _Book1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1132);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAJ7");
            sb.Append("SURBVDhPrZNNTxNRGIX7D4yJoqINFCw1SoAIiDEIQtQCLTNlaHFqsEhLUsqnBUUBFxhDaDQuTARX7k0E6RdSKoGgMQZLGcDauXfH7P0Px1dx0zBLJjl5k0nO85575o7B");
            sb.Append("cBSPffCdwWWO/3JbPqWd5hhc55cgm+NwFsfRXhSDZCIVRuEonEej8e1+bWcody2ZlWHHV7yf/YFkRMFKeBur0TQS4S0kFlNYmt9E/MMmvn9JI5VKoSyvBzkE2RLffzGe");
            sb.Append("gd+6ju6aVVLynzzVK/BU0axcgZfm32TCubAOoGRJm5nIINizh7mXHHMh0gzH7DTpOcfrKYZXkxyhUYaOkqgOwBzXZp5kIN9U8LQvi0c+BWPeLYzc20LwbgoDzl0Md6iY");
            sb.Append("HmKQinUSUFla6HEGYv0mxnp2sPGZYz3JsZb4r2WOgPATU34VUlHkcAJqWnv2YA+O698w0a0i6FbQ155GQNxGwJ6G77YCvy2LSS9Dm0kvgYkAg3toqtlAUOYYcTH0iSqZ");
            sb.Append("OHy3ODw3VNxv4BiVsxALPuokKIxpk34FQvUaBkSKa2O0lZFJRWctg/sqh1zDCJyl+7B4GCAVRLVxr4K2ylX4rCq6Ghg8dQcmVyVHewVHx2WOh5IKwaiTQCqIaGMeApQn");
            sb.Append("0EVG9zWOO9UcjvIshIsMooXDdYljoEWFw6iTQDwb1UapOGdZAu4rHFIFfa5SDuECQ6uZo7WI3tEcbuKw5S+g9ITvd85NFPIj2oi8iyHHDvoFhn47R6+VIWClPhpJVGBv");
            sb.Append("PcdgI4OdAJZjnsUcQF33G0ObMUbni9GGCFpJ9jNh2EgtpyNoPhVGc14ETSfDsB5fWDZVCUfxDx8w/gAEr7E/uMp0fgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book1_Reset()
        {
            _Book1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book1 = null;
        #endregion
        #region Image Book2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2_Cached
        {
            get
            {
                if (_Book2 == null) _Book2 = Book2;
                return _Book2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2 { get { return _ImageCreateFrom(_Book2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2_FromFile { get { return _ImageCreateFrom(_Book2_string, "book2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book2
        /// </summary>
        /// <returns></returns>
        private static string _Book2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1164);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAKT");
            sb.Append("SURBVDhPrZNJT1NRGIb5K7oyrtVExTI5gtEVQQSZ2jJYCCAGBK1CFERMSLEDHSiDTC0IEpTRkApSCr1IqVRGBy4iGNGwENePJ7giZclJ3uXznO97z70hIQdxLufYQ2Jy");
            sb.Append("7B9jsu3vo7PruKQRuWnjosiFLCvnMy2cyzATpdKjuPFoNTSxcu+1AvbdqR1myL3IwpcfzH/eZP7TBoGVdeaWv+FfXGN2Qeb75hbb29scVcSxxxCTXbfaOrZEXk0fyaWd");
            sb.Append("JN137iZR6yDhnoPrd9uJL27bnSxCZQoWRGvqZOfkZ4wjAYYCG/T7N+ibXefVzDd6pDW6plZxer7S6FomWmMNFoh95Tb3CoXtE9hcS+gH/FT3SFR1e3ncOcnDTonHPX5s");
            sb.Append("bxZFL5ZggShLbhEr3GoZxTD4gfXff1n7tYMssrq1w9eff3jglDANzotS9xGIpuUG1wK5DSPo+gJUdkmUOTxoWycoaRqnsMnN3XYJ3euAeBFz8ATnMiyydThApmWAJ71z");
            sb.Append("VHT7KXvh455zhqLWaQqavdxulngi1jibvk+JZ9PNsrHfj1LXK8BZtAK80zYtIC+5jVNo7B409R7KhTRKZQyeIEpdK+t6fSRVdlHcLsAWibwmAQoowzaBsnYctdlNqZBG");
            sb.Append("KA3BgkiVSX7aPU18mYP8Ji85DZNk2jyoLOMkG9+RUDNKUs0YJWKN8LR9BOFKk1zR4SW2pIWsXdBNigATn41yrfotsU9dxFW5KKyfIixNz5HQ2F97vsSwNKNc3iGhbfZQ");
            sb.Append("2ulD65ihWJRX9FyioN5Lvm2KXOsk+RYPilQ9h09cfblHoEg1hESqzUSoawlXmwhTmlCkGTkjxg1NNXA6Rc+pZD0nk55xPL564NCxKwfxD/93/AOyE+YLupmrIgAAAABJ");
            sb.Append("RU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book2_Reset()
        {
            _Book2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book2 = null;
        #endregion
        #region Image Book3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3_Cached
        {
            get
            {
                if (_Book3 == null) _Book3 = Book3;
                return _Book3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3 { get { return _ImageCreateFrom(_Book3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3_FromFile { get { return _ImageCreateFrom(_Book3_string, "book3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3
        /// </summary>
        /// <returns></returns>
        private static string _Book3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1116);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAJx");
            sb.Append("SURBVDhPrZPNU1JhFMb5U2rRtG+aykDUxFbViKPVFGUlmoAXUD4F1MwEjCSRb+TyJZ8qOgKONiqiNuOYqav23n3/w9OBVgwsvTO/zXvveZ5znvdcHu86nicMy+uyaP50");
            sb.Append("WbTnIvMYOs0adJrG8IjoMI2iY1yNdqMKQu0IWmT9VwKJvd6Wii/l/nlES5vYOT7E9lGlxlaljNLBPorlPRT2d/Hz5ARnZ2e4/bgddQrkfOUqZjGwaEPf3BR6bZM1eqwW");
            sb.Append("YgLiWQu6iWpnAj3TKCAyazj39iq+bEQRPyghUi6BLRcR3isguLsJ3491eHby+FbKQURjNXRA83KurRUoEk7YiylMr0UwmQnBlA7CmPRDm/bDuBqGvZCmPJSNAhQWt0Aj");
            sb.Append("fGTn8DkfxfHlbxxd/MLhxSkqxMH5KUZTXupwmQRUjQKUNOfYTEEatOJTPo7xdACahBtqgom6II+5oCSB6rsOY5MO2sfVnG19Gf3eaZjyLAwrYWiyAagyfihSHgwvuyBL");
            sb.Append("umGi87ZmIbYZVdzMWgyvFqagzYWgzvgwQoUyKpQmvuNDvIoT+uwShLomtyA0KLmpHIvnjgkwaS+5LWIo4aoVvY068Jp14E3EgTEaTUDL1HALrXolZ84sQWwzYYhcB8i1");
            sb.Append("PzYPCfsVL8N29IaseLE0Bybpay5Ay8EZUgE8nTHgXcwJCblVC/tCs+ihYLsDsxAHbJAnfOBr5bglEv6t20S+boTTU3uqhIfCC1IGATApHxRJL4bpbIiQxt0YjLnxkARu");
            sb.Append("tLVs1AkI33t4rXQ9AgNDq6oAX6eofdhCPCDua2WEHPc0MtxRDm7fvPvsOv7h/xr/AExhvoJ2IOctAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3_Reset()
        {
            _Book3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3 = null;
        #endregion
        #region Image BookLink
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu BookLink_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property BookLink, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property BookLink_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink_Cached
        {
            get
            {
                if (_BookLink == null) _BookLink = BookLink;
                return _BookLink;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image BookLink_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookLink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookLink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink { get { return _ImageCreateFrom(_BookLink_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookLink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookLink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink_FromFile { get { return _ImageCreateFrom(_BookLink_string, "book-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru BookLink
        /// </summary>
        /// <returns></returns>
        private static string _BookLink_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1680);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAqhJREFUOMt1kl2IVGUYx39nPHPO5pjb+MGwS+ugKeSuo3cGlV8RQQiFQrgWdJEgwgZdhBfRbTcrJRLlVVCIV+VFd974SV200ArBorkY5mH3");
            sb.Append("HGenmlmdM3M+3vd5ujjumrE+8PLCw/v/Pf//w+uoKm999O2Yqv6g0EZ5WVFUAVWKS5eP2Jw8Xbx7/dynWwBcigfHFV5sjG5yFlqLqC6JoIAJKtBZjOmniqi7mUdVAGBv");
            sb.Append("Y3TEObBzhE1DDbQgICrFVCmmb3xuNasHXF55+wRPAFCtNsbqXPz1Du12DxUBQJZcqKKidB70SNKM/9ajCDiu57JtR52ttXVYC6qCiGKtYkUwovSTnO8vXFsJoFgr3Ft4");
            sb.Append("gFcqkyQJeZphpOgbVuGWPTZUfER1BQAgVjA2J01TDu3eWtgv3KGqfHf1d/KBMv/TP3aQW8HmBmNLnL92kzQ3GKtYIxgcyp5HZoqlrggwRsjynExASz5OuQwlRRxBRMis");
            sb.Append("Q2afCoDcWExi6PX6xHM3GcyabK5t4I8gIl6/C/wKD+/+wtGXatwbGmNiYuLkzMzM2ccOrJD1E4Ibl9k1/AxH3nufOI55YW6Oyz9Nkegq3n3nMF7ZJYoipqenTwVBsPGJ");
            sb.Append("CO3gNtsqD9nz2kFOfnaGf/6cYXhoiEajQRRFnP7ic8IwAm8Nn3z8IUEQHHeXPkxmLPFCwNqdIwAMjL5J79Y04+PjVKtVut0urVaLL786y1/dCgCDg4P+8g6sVRy3Qhg1");
            sb.Append("Aejc+BFQJicnqVQKQRzHlBx4/lmTAAPz8/PJcgRKJXbvf507P1/gyqUrHH7jVXx3D81mk9nZWXzfp16vU6vV6PUTZ2pqqhOG4X1HVdn3wdffqHJMVSDrsKb7G8O19fi+");
            sb.Append("hwPcbq/FqMf26t+UHJUsTfphGLbiOD70L9sBr2vImxxTAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0RVh0ZGF0ZTpj");
            sb.Append("cmVhdGUAMjAxMC0wMS0xMVQwNjo1Mjo1OS0wNzowMMfktvQAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTI6NTktMDc6MDC2uQ5IAAAAYnRFWHRMaWNl");
            sb.Append("bnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uG");
            sb.Append("PGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NDk6MjItMDc6MDDiIWJzAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0");
            sb.Append("U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAA");
            sb.Append("AABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property BookLink_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void BookLink_Reset()
        {
            _BookLink = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití BookLink_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _BookLink = null;
        #endregion
        #region Image Book2Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book2Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book2Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book2Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link_Cached
        {
            get
            {
                if (_Book2Link == null) _Book2Link = Book2Link;
                return _Book2Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book2Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link { get { return _ImageCreateFrom(_Book2Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book2-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link_FromFile { get { return _ImageCreateFrom(_Book2Link_string, "book2-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book2Link
        /// </summary>
        /// <returns></returns>
        private static string _Book2Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1252);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAALX");
            sb.Append("SURBVDhPrZPrT9JRGMd538v+g5qkZE3xBXOlmKamiM0SL2WZiGiili1J8ZppmjHTId6QmcsL6HTMW15mYstLUimFohDpT01aWuiy0Zv27ed55+xdne27PefZOZ/zPN9n");
            sb.Append("h8H4HyssXc3gpatneGnqt6FpTQiR0EpV4QKt4JuNCEppQGByPQJECvheK1k9G1d+8Fn68lx23QiGJ5dg/vQFizY7Fj9uwmTdwAfLOoxLa5g3U/hs34LD4QDLNxoHCLy0");
            sb.Append("ptW2l8u4XT2A+KIuXC/QEsXla3A1T4MruR2IzWknlZ0T1R4GhEqaKO2MDcoxE4ZNmxg0bmJgfgN979ahM6yh+/UqtNMreDpuQaik8TCA7pdqn7RC2jEF1fgyFM+NqNQZ");
            sb.Append("UNEzi7KuGTzoMqBMZ4RqdIn2peEwgDaLaqVbuNM6gZqh99j49hNr23ugaK1u7WHl6w8Uag2oHVqkTf0LgHaaah4341bzGKoGTCjvNuC+Zhr5bVOQtbyCtGUSuR0GVPWb");
            sb.Append("6InUH64gMLmBahwxIaFSB/mAGZmP1CgsLoVGo0GmNBeS6l5kqPS4KysguSxpNgQCQZaLi8sRMo3z4npKOWhEVNEzRIjvQaFQwOl0Ynd3FxaLBdK8YqTLSvDdsUNyNpuN");
            sb.Append("nGGz2RUEEJBUR1X1zoETmYFEcQrs29sIjhLCk81GeHg4lEolJBIJiT092fDk+BKIUCjcIQB/US31uOcN3M7wkZObRwAipR6uLHcsLCzAbrfDarVCr9eD6crC0RNcApDJ");
            sb.Append("ZE4C8EuspR52zoLFjcElQQwB+ITF0oCTcHd3B4fDIdqPXd1YOMX2du4DIiIiHATAFSqp0k4D8puG4XM+BPIn1RgafYGJiQmo1WrEx8cjNTWVxPu53r7+X3K53OHl5WUm");
            sb.Append("AN+EGoZ/Uj2OB+XgGDcFp728weNfRGRUNAS03PxuwIUrxmW6Onr/m8/n73l4eKwwmcx//8t/AB6S+IoSY/TrAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book2Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book2Link_Reset()
        {
            _Book2Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book2Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book2Link = null;
        #endregion
        #region Image Book3Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link_Cached
        {
            get
            {
                if (_Book3Link == null) _Book3Link = Book3Link;
                return _Book3Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link { get { return _ImageCreateFrom(_Book3Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link_FromFile { get { return _ImageCreateFrom(_Book3Link_string, "book3-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3Link
        /// </summary>
        /// <returns></returns>
        private static string _Book3Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1224);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAALB");
            sb.Append("SURBVDhPrZPdT5JhGMY977A/wFLACWssW63mJwiIZEvSmlNnFvmZIorKhyCZoZilkRZiKCqKmR+lwBRF/KLMD3TzpMN8/wI7aLOTdvXwtA6cndW7Xdv93M/7/u77vp7n");
            sb.Append("jYr6H09W9UCU2KD+LDbUh0VNdUhvUiNdXwchkUBfC4FOhTRtDVLqq3Ct4u5hUqHlZFny8X6l7Tmc3lksbKxhfn2VyrcahHdlGZ5gAHPLSwhtbmJnZwdxkjScIJDKh1bP");
            sb.Append("WyhetuN2hwm57c1Ut9oMREbIzQZkE0U6S2qsPg0QNamZnvlJPHnvxPCKF4NBLwaCHjgCc7AvzeK1fwa9C9N45p2AiIx1qgMyL2P1vcPDkS5YPGNomRpE83g/9G47tKM2");
            sb.Append("1Ltt0E46YJlzEz+UpwHELOYFGaFsoAOPp53Y2N/F+t421va2sEq0Et5C7dgr0qGLAGpOA4jTTOfsGB7Y2/Boehg6dx/UIz1QEVU7ragcskJJAJE9gfYvHaTpVEz7jAt5");
            sb.Append("XUYYP4xA0aJFlUqJ7u5uFJeVoNjaCoWjE4rKcppTlJZCKpU2REdHn6GnkaqtYVqnhnCztR4Z9/NhNBpxcHCAcDgMv9+PEmUVipQV2N7dpblAIEDf4fF4TykgRaNkTBMD");
            sb.Append("SMi7gdy8O/i49Qmp8uvg8rgQCoUwmUwoKCigMZfLBe9SAoXk5OR8o4DkRiXTNP4G7JSrKKuooIDCfgti2Gz4fD6EQiEsLi7C5XLhHCsWZy/yKKC8vPyYAsjlYDRjfeBI");
            sb.Append("UiGRSSngSqaIAFhgEwifz6eKxDEsFuL4F44jALFYfEQBiQ1VTCNxXkmu8+XkRGj0OjiGnRgdHYXZbIZcLkd+fj6NIzmb3f5Do9EcEQ++/PbgXm9UMjme2KJcnJdnRiog");
            sb.Append("LV2IDFkmpDIZOFkSsLJlf9Y/BQLB9/j4+K8cDuff/+Vf7ZbNoSxh68YAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3Link_Reset()
        {
            _Book3Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3Link = null;
        #endregion
        #region Image BookOpen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu BookOpen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property BookOpen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property BookOpen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen_Cached
        {
            get
            {
                if (_BookOpen == null) _BookOpen = BookOpen;
                return _BookOpen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image BookOpen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookOpen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookOpen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen { get { return _ImageCreateFrom(_BookOpen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookOpen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookOpen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen_FromFile { get { return _ImageCreateFrom(_BookOpen_string, "book-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru BookOpen
        /// </summary>
        /// <returns></returns>
        private static string _BookOpen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1480);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAhRJREFUOMulkzFrFEEUx38ne8l5kLuNotEkikoW8QhanHYHIYIRxEILv0HEysbKxkrwA4idQoqUYhFQITZipYZEgrHxDjFyhciluXMD2Xnv");
            sb.Append("7Vhs9kjgrDIwDMyb93+/+c+bgveeg4wA4O6LlXq+kZphu3Px/swawO0nr+sqgogg4hCXrR+f3VsrzD//XAdWTx8tk6aGWUpqRuKEn3+6F1WEidHDX/GGqqIiqCrffvxm");
            sb.Append("uDR8OfCprVI4xMOb5/tYaZqy/OUXzXZnWUW4dinixpVz+9Dr808ZKhZXAwAzA2BjYwOzrNLs9DRnjwQnR0YqnBobZX19HTMjjmMajQbOJYgbyjxQVQCiKMLMEBHa7Tbt");
            sb.Append("zU1qtRpJUiaKIkSEXq8HgEsS3PAQgfegIgA0m03SNEVEqFar9Ho9kiTpx1SVOI4ZHx/HOYc4R5CaIrsCURRlRqnS6XTY+8RTU1OoKt1uFwBxDhEhUFXEObz3tFqtvgeV");
            sb.Append("SqWfnMdygsnJyUzA7RHYS+CcY2trC+99nyInyD0QEVQcgUqWAFAqlfoVy+UyYRgShiFBEFAsFvcJ5lcNRBwuSZh5sNDvsBzvVuMC3nsW337KKqpiu4lmhooSiAhnJo4N");
            sb.Append("7PNXH1ZQUa7PzQ6MLy29IdjZ2WGz93dfj+cEJ8aOY2Ysv3s/kCA1o/C/3xjdebywvR1fVRGq4ej31stHc4POFQ76nf8Bhkab7qafS2MAAAAldEVYdGNyZWF0ZS1kYXRl");
            sb.Append("ADIwMDktMTEtMTZUMjI6MTg6MTYtMDc6MDD9d/V1AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA2OjUyOjUyLTA3OjAwxePiDgAAACV0RVh0ZGF0ZTptb2Rp");
            sb.Append("ZnkAMjAxMC0wMS0xMVQwNjo1Mjo1Mi0wNzowMLS+WrIAAABidEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMy4wLyBvciBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8yLjUvi4Y8ZQAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwNi0wMy0xMlQyMTo0OToyNC0wNzowMIHxV0kA");
            sb.Append("AAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAAG3RFWHRTb3VyY2UARkFNRkFNRkFNIFNpbGsgSWNvbnOCemT7AAAAM3RFWHRTb3VyY2VfVVJMAGh0");
            sb.Append("dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay/CxA0NAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property BookOpen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void BookOpen_Reset()
        {
            _BookOpen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití BookOpen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _BookOpen = null;
        #endregion
        #region Image Book1Open
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book1Open_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book1Open, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book1Open_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open_Cached
        {
            get
            {
                if (_Book1Open == null) _Book1Open = Book1Open;
                return _Book1Open;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book1Open_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open { get { return _ImageCreateFrom(_Book1Open_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book1-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open_FromFile { get { return _ImageCreateFrom(_Book1Open_string, "book1-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book1Open
        /// </summary>
        /// <returns></returns>
        private static string _Book1Open_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(988);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zgnpk+wAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACOklEQVQ4T6WTzWuTQRDGB3pQwaCHHqSoOWjbpPmUFYtSv9oeSm2TFkQQ");
            sb.Append("b4Ki/hEitFiKSdCLxVgSImIS83V4ExITEg1N80nyhiaNybGX/huPu1sTKJpTD8MuMzu/eWZ2lwDQSUwm2yw91je7ke+numxpcp/1wfPaGrt/scRuX9hh06NZduP8D2Y9");
            sb.Append("q8h4Pxmv7D1pLx908WJxH0/n9jCvbZjmLldNT2YqeDxTwKObeTyczmH1ehrmU1Fc08QZrVh6sJl7aLfbA2u1Wvi0qWL2UuXw3tju4dZG/VhcnNWPBMA0CiRg2XAEiEaj");
            sb.Append("CIfDCAQCaDQaUGI7+JVW0el0EIlEEAqF4PP55NlJ+gLrmcgRYEnXlU6RVKvVUCqVkEgk4Ha7kcvl0Gw2Ua/XUalUkM1m/wK2oRv5BuJDw8LVPekUVYQCv9+PeDwOl8uF");
            sb.Append("VColASIWDAbh9XohWtTTR4yTD7Rq/C2GJQH9KsViUQKcTucAIJSVy2VkMhkJMNB7DtgGLevbYlgDBaJPoUBRlAFAVdXBbDwejwQY6R1XsQVaHG/i7ljhmIJCoSABDocD");
            sb.Append("yWQSAlCtVuVs+gpMtAEdfQAtXGng1ujPf65RtJPP52WyqChaFKtoT6xmWucKXKBZbRn8ZYG/LFhOx+T9TtBXTvfhuT2GZ7YopnglAzm47E2e+BYWWuP2RvroDpe/Yt39");
            sb.Append("r03QZzntYXEDb4P42x6qgJ2LwKr5PlSBhV4P/4m8BS+vfsCv64Dv08N+7Im+soD+AamNm3YVFSbbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book1Open_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book1Open_Reset()
        {
            _Book1Open = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book1Open_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book1Open = null;
        #endregion
        #region Image Book3Open
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3Open_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3Open, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3Open_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open_Cached
        {
            get
            {
                if (_Book3Open == null) _Book3Open = Book3Open;
                return _Book3Open;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3Open_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open { get { return _ImageCreateFrom(_Book3Open_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open_FromFile { get { return _ImageCreateFrom(_Book3Open_string, "book3-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3Open
        /// </summary>
        /// <returns></returns>
        private static string _Book3Open_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1032);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zgnpk+wAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACWUlEQVQ4T6VT7WvSURT+fYsoimJBg0VQjCgyaD/m6I0tLEWXaxmaLh1z");
            sb.Append("NceoZDSrTWi1ycTmT5kfZpsLzSBUfPmioiQKgvky2Qts7Pu+7N94uveGwig/7cPhXu455znPc+45HADuKMaSDT9cfMOG/E5e+83Bq1cX+AZwv9vKy5zTvMRu4XvnzPyd");
            sb.Append("j6948fQY8zeSYYmuYSqyismQF+afXkx8X4LSMytSuKyika8OjCzbYfDYoHPNQrNoxc0pI3pmTDynDzihDwrY3d1t2s7ODnzpBOTCzIH0y/uDlWT8kJ/GXn+jh/iDCQxA");
            sb.Append("519kAYlEArFYDOFwGJubm0jmsihUfmNvbw/xeBzRaBTBYJDFXhnXoOvt6F8AzZqdPdKker2OSqWCdDoNn8+HQqGA7e1tbGxsoFarIZ/Ps9hLxicQvR4CR5oGlXeePdIq");
            sb.Append("lEEoFEIqlYLb7UY2m2UA1BeJRBAIBEAlXtA/wlXCgiMdp81iAI0q5XKZAbhcriYAZVatVpHL5RjA+WcydL5QgVOvLNBmNRlQnZRBMplsAmxtbTV74/f7GUCb6j4uDg+A");
            sb.Append("Uy3P4aHj3SEGpVKJAQiCgEwmAwqwvr7OetNgcFp5Dx06ObgBzyf02Sb/+UYqp1gssmRakUqkJ5VHz5OK22jXSMEpBCvIZIFMFroso7hhNuDahBadY2qMCzaYnPNo18rQ");
            sb.Append("9lSCM4N9OKW8ixPyWzguE+OcSgJOSuhrlj7/1y4bB4lOZUv/2ce94Mhst2TQY3mJbjIsrRgce9DdehOJhEDH8/598l375P6r1cYeaZUp6B/IL6ZW8ozCcwAAAABJRU5E");
            sb.Append("rkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3Open_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3Open_Reset()
        {
            _Book3Open = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3Open_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3Open = null;
        #endregion
        #region Image BookR
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book_r.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu BookR_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property BookR, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property BookR_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book_r.png
        /// </remarks>
        public static System.Drawing.Image BookR_Cached
        {
            get
            {
                if (_BookR == null) _BookR = BookR;
                return _BookR;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book_r.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image BookR_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookR_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookR_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book_r.png
        /// </remarks>
        public static System.Drawing.Image BookR { get { return _ImageCreateFrom(_BookR_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book_r.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookR_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookR_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book_r.png
        /// </remarks>
        public static System.Drawing.Image BookR_FromFile { get { return _ImageCreateFrom(_BookR_string, "book_r.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru BookR
        /// </summary>
        /// <returns></returns>
        private static string _BookR_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1144);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAslJREFUOE9tkts3lFEYxv0r3bXqNh1FckhUNx0sZ8b5WFoVchwrIWUG4zDMNBTGOIRQ1CqxDM18M2NIiCgltVZr5T/o");
            sb.Append("1/7mjq+L52rv97efdz+PF+Alyzfm3mZAUgNBqS0Ep+k5l95KSEYb52VlGgjNMhCWZSQs22i9kG1cvpjz+LA85xmW5RNdRUBKM+KQ6KIeYkp6iC3tJa60j/iyPhLU/ajK");
            sb.Append("+8lvfi1D/op7dXsAh3zD2d3d5cfP37hXtlhY/caHte8srW+z/HmH5Y2frGz+YsK6KiCvZMi8AuCf1OSxG1HQTWShmSjhJLpYOCmxeBQnnNyoG6Nr+pNYx/BVAQjNbKV9");
            sb.Append("cg3L3BcGbF8Zkr4x4vrOmHubFws7TCzt0PhmCcv7DUIzDVsKQEiGnrbXq5R3zVE94ODBgMSjQQfa5y60I/PUjbm5Y56l27ouf64ScC5dT9P4MmqzjcpnTioFpGbQiUYM");
            sb.Append("a0bdaATgZucUnWIFkZASEJzWgnZ0iYIns5T0SBQLkNpip0KA7stAAbtueoNpckWOWQkISm3mwfAit0xW8rvsHhWaJcp6naj7HJT3SaS3jos1P8pdUQICk5vES25y2mbI");
            sb.Append("7bB5dLvTzl2zQ0iiSDhKrh+l6eWiKNx/AGeTGinvcZLWNktK6ywZxjly2m3ceiqR1+2gyOIivmaQevEfgSktSgf+iTqKuxwk6GaI1U2TqLd6YJmP35P7xC7cSERV9FI7");
            sb.Append("5CIguVkJOKPSkd9hJ6p2Cv6Ihu9TjslGeEk3Vf0SonR7AQd9rm75qRq4bbRxtWqSy9VvufbwHZHaKY8bVcsMqWKtK/lPqRDJnEncBzhw5FKHb0IDufo58kwSdzucFHa6");
            sb.Append("KDXPo+51iygXqBpapHpwgQqRiJ+qca8DuZbeEbXD3pG1HI3UcCxKw/FoLcdjtJyIqeNkbD2n4urxiW/gdLwO3wSdQZ75B5C5uGxOamN1AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property BookR_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void BookR_Reset()
        {
            _BookR = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití BookR_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _BookR = null;
        #endregion
        #region Image Book2R
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2_r.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book2R_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book2R, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book2R_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2_r.png
        /// </remarks>
        public static System.Drawing.Image Book2R_Cached
        {
            get
            {
                if (_Book2R == null) _Book2R = Book2R;
                return _Book2R;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2_r.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book2R_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2R_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2R_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2_r.png
        /// </remarks>
        public static System.Drawing.Image Book2R { get { return _ImageCreateFrom(_Book2R_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book2_r.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2R_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2R_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2_r.png
        /// </remarks>
        public static System.Drawing.Image Book2R_FromFile { get { return _ImageCreateFrom(_Book2R_string, "book2_r.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book2R
        /// </summary>
        /// <returns></returns>
        private static string _Book2R_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1140);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAKB");
            sb.Append("SURBVDhPrZPbT9JhHMb5V+qqdV1tlaF46KCtrpyZhnLyEDizHHmI0pV52hz4A+QgoKkcRM1ZitocYeIP+JFIEqJm8lPTljYvsuund3bF4NJ3ey6/n/d5nvf7cjincW5X");
            sb.Append("mTh5VaaveTLT51xZL25JiR4acZPoRqUB1yv0yCnXIUtMgfvgVTytuC3xWjIcquuZxYw3htXvPxHd3Ef02x4iG7tYWd9BOLaN5VUWP/YPcHR0hPPcAiQQ8mS98aH5NTxS");
            sb.Append("TaKkyQn+c8eJihV2FD2z436jDYX11hNnPLE2GZAr7WUdvk1o5iKYiexhKryHyeVdvFvawTizjVF/HA56C33udeRKDckAkpe1ejcgty3C6F4D5Qqja5xBx1gArU4fXjoZ");
            sb.Append("tI6HYfwQI73okwGkLHaQRHg86IF6+gt2f//F9uExWKL4wTG2fv3BCwcD7XSUlJoCQJpmLe5VVFvmoJyMoG2UQbOdhmJoEQ39C5D3e9FoY6B8HyEvokt2kFOuZw2zEVTo");
            sb.Append("XWifWEnpoHaAQTuJkV2WosTsMh2rmQpDpJxA88gyFI4l1FmDqB0IoLrPD6mJhtRMo2UkRHZBk+wgS9LDKidC4LeNot4WTOlAovOiiUB5InUyIFOsZTvHgihstqOmP4Aq");
            sb.Append("iw8VRhpi/QJKNJ9QpPKAr5pHA4mRIUwByBBp2dfDAeQ3DKLyZNCLUjJY3O3Bva6PyO90o6DDDbnZj3QhhXNp+YcJm5gu1LAtwwwUAzSanCEo7EuoHwri6RsGT8wB1Bj9");
            sb.Append("qDb4UKOnwRVQOHvp7tsEAFeg5mRKdOBJepAh0SJdpAVXqME1YjdNoMbVUgpXSihc5nfjYmGX68yFO6fxh/8z/gEDo+7EUVeqTQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book2R_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book2R_Reset()
        {
            _Book2R = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book2R_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book2R = null;
        #endregion
        #region Image CodeClass
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CodeClass_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CodeClass, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CodeClass_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass_Cached
        {
            get
            {
                if (_CodeClass == null) _CodeClass = CodeClass;
                return _CodeClass;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CodeClass_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass { get { return _ImageCreateFrom(_CodeClass_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru code-class.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass_FromFile { get { return _ImageCreateFrom(_CodeClass_string, "code-class.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CodeClass
        /// </summary>
        /// <returns></returns>
        private static string _CodeClass_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1520);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAADdgAAA3YBfdWCzAAAAAl2cEFnAAAAEAAAABAAXMatwwAAAitJREFUOMuNkktIVHEUxn//e++MZkVm");
            sb.Append("+EqyEJLIqJAWhhHULKpFGxdtA4Ue0GJoE0agkCgEUUhgELrpsdFaFVSik1gkJKI0aoKZ41jjY5wcnblz3/8WhivBOevv/M453/nEcPTV7c8zz9qmlkJ+ACGgeFdlpvrA");
            sb.Append("lebLVS0P2KbE/XfnzKuBBr8HeJ6N41k4XoqP34YIBroFQODxEH3Bmi0B2tepkP/MiWrSxhqOa+J6NqoKvd+7N0V9wRreT8Qb347+bh2O/AWgYGcOwUBFu5Zch/G5UVL6");
            sb.Append("OqaTIW2ukjLjpE0NcDqAHKC+Z3Citex0DeePSAxHYtiSL+PhW9paSqV/JITrCRQhQAhURbAS9wBuAk+ApwPhCJX7q9B1i7ThspgW5IbHFM0nCjKKtHbYjosEJKD4VPLz");
            sb.Append("9gKzAHlAvZ5YuD4yuYxlmRsa1Y+TTKCV5JffS6zoD2cWfm3eXJS/j/Lisjv/ARIgV/OIk0ZRJAC26lC622+I7d4EdAINl9qeN83OLzZPR2IAlBYVcOrY4aYs+ukEkFJu");
            sb.Append("OUzJhrARMCG3zEG2APPPy8bVn12txlI/AGpOCXuOP2rPxoMuoH76dUBW1F0AqYB0QTGZ64162WwggY7EWB+HLlbiZpJIN4kqw8x+iinZABoAFqLKDTvag6Wvg3Tw5fpI");
            sb.Append("xtzsPbCdQlLLqwgpAA1L98B/0FA/3D3Li8HItoBrdbXujwFRO/JmWZsMucxPlBiFR0+2/AM8rPM5fdqBuwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNzow");
            sb.Append("MjozNC0wNzowMLbnjhIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjQ6NDEtMDc6MDA79Ej8AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5");
            sb.Append("OjI0OjQxLTA3OjAwSqnwQAAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2");
            sb.Append("ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDctMjFUMDk6MjM6MzItMDY6MDCdbbIWAAAAE3RFWHRTb3Vy");
            sb.Append("Y2UAT3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CodeClass_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CodeClass_Reset()
        {
            _CodeClass = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CodeClass_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CodeClass = null;
        #endregion
        #region Image CodeClassR
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class_r.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CodeClassR_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CodeClassR, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CodeClassR_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class_r.png
        /// </remarks>
        public static System.Drawing.Image CodeClassR_Cached
        {
            get
            {
                if (_CodeClassR == null) _CodeClassR = CodeClassR;
                return _CodeClassR;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class_r.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CodeClassR_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClassR_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClassR_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class_r.png
        /// </remarks>
        public static System.Drawing.Image CodeClassR { get { return _ImageCreateFrom(_CodeClassR_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru code-class_r.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClassR_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClassR_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class_r.png
        /// </remarks>
        public static System.Drawing.Image CodeClassR_FromFile { get { return _ImageCreateFrom(_CodeClassR_string, "code-class_r.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CodeClassR
        /// </summary>
        /// <returns></returns>
        private static string _CodeClassR_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(940);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAi9JREFUOE+lkm1IU1EYx4/btAmB9CIhVpOixA/7UjACKVyDoK0SbREmFUqSrvoycdQS53pxbdm66rAGvRDWqNnApcES");
            sb.Append("xaX0gqlgMDWRMFsvo/XBXnZ3q91/996crA81owM/zjkczu/5c85DyAJGZ6DWYPatj+juElS1/4J6qGSGXrv0f7yuop7On1G9ezD26QImvzjxMnId09GbmOE4fV/JkO5A");
            sb.Append("qEnd/ASbLH6Bo65R+MbCJxLNGoqgY7IEnvESdLw4gK6pCvQFq6G2ExCT+1lM94iGfjAK4wgD0/NvOOTsx5zgGjdfKrBKoHOnw+BdBbNPjnM9Cjgeq5Bv5gS5uiuQtb6B");
            sb.Append("4kYQyjvvoOn8iHXH2njBZQ4HL5LXiKBtTUORIxVFLRIUNotR7BBBXiMGyS61YbllHEvPjGIZR5ZtAtml5xMTkM2mHOxuycBO+2Ls4uBnLbffYMiMEHklRWfYhrGkYUiA");
            sb.Append("X689aI0LrvIJtBfzDYrjMuRUSufZWp8HdcNGPSm2u+tWl59F6o5qgbwjjdhuaTPNvYEg+OcBIOW/BAkVkyf4PHO7KdiVhVeeFIHQgArM21vxPkgumO6uiLE4BTZmBcs2");
            sb.Append("goUNUx7Vb7/w1zfwG9Pw/b0M0ZAGTHgffnytwmAd1yBcA3EkT+AtEyMSSMfssASzI1LQE5m4VyaKJ0j+Ad7Da+gPA4sQ7pcK8GvP/hULF/ithSdde1fSzgIReNrLc6M9");
            sb.Append("9dtqk5cm5IFxC/kJuMw1p0by7zoAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CodeClassR_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CodeClassR_Reset()
        {
            _CodeClassR = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CodeClassR_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CodeClassR = null;
        #endregion
        #region Image Configure2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku configure-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Configure2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Configure2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Configure2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2_Cached
        {
            get
            {
                if (_Configure2 == null) _Configure2 = Configure2;
                return _Configure2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku configure-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Configure2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Configure2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Configure2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2 { get { return _ImageCreateFrom(_Configure2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru configure-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Configure2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Configure2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2_FromFile { get { return _ImageCreateFrom(_Configure2_string, "configure-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Configure2
        /// </summary>
        /// <returns></returns>
        private static string _Configure2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1868);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
            sb.Append("qklEQVQ4y22Ta0xbBRiGv3Or7TmnFHpOS2kPbVnBrUhn5gJCMjZxOLYMhzGZ4rJEjT+MGLPEjEAWbzET2UWi0ezioiZLDJlzRQZsHT+8jRoG0qEMGL2vpbS0KYXSlt5O");
            sb.Append("jz+MM1v2/X6fJ2/e5EM++uBDqraurmHUYpkp1+mWj3YehUcc2tPzaS3HaTaDAHPZLH97bnaG7/u8D1CHfUHOskz3821tJ68Njyh/vPTDw/Bjp0+eOrizcce3CgV7Tijw");
            sb.Append("7fNzs5JEMokCAKBer2fJ4/acpSiyvqu7qzObzYqvDpjv0zVPmNjnWvZ0VFToq4OBgC8YDP2qVLJd5Rp1MQAASlM0337oFfP42NhbpES8S1WmOhaNRomL330DAAC7m5pk");
            sb.Append("MplMLggADMNqDZVVxzUct3k9Ec8CAGAujwcAACyjo56BS/3TWp3ubYqmtf5IxPqqSMcnKtQ1SpZ5fco2TTIKJcFxXOSv6b97b01MOZ1OewH/r6qcIMDp802azeZuo8n0");
            sb.Append("xTa9NnXZ5ey/kX/ySJJF2O1KMrwYCNnSG5nf7QsOqwD5HAAA8ojFkf7vL+58mlGciI7dVlotM7oL6sO2rao7fbTgsgaWIiF9OZc9c+5LAADAHqabP7kFI9e8Od3C5EtP");
            sb.Append("MYLJsLGI1M0Nnm4wpC6k7Utr3LO7+d4Tx+/nHxA0HrMCXiTVuNel5+N35psqnTeR4spNQOB8tds6Hc37ff702G8bh4qkcDWZelCwrfNn4DRFZYF7ifNhP9KaqG/hkULy");
            sb.Append("jGripxDTuKtOrFLt83k81elc7s+BdDZ2L5f7X2DqngVMWFeFfOmvFl2ZF4q2GARcQZmvV+17t2X4vfm1lVhz1f79LKlQGMNOx/ZKFBl/jaIj5lQKsNKDQ1DCYMXJhKg3");
            sb.Append("6Mq0kzo9Ki0T25ft3iOqEsTb9sfZQDi+Hs/7/c3GAwdEkhK5Nu5wGPOZzC89O7bGMbrmMCpQ2g5EzL5BlSopSkmF48uxjhfrr9yceP9l6EcxaEBxp7C2pkDdbtPjra04");
            sb.Append("SZIVokiElcrEFoxPFuNImekddgtjoiT5TGBq8uPojVMDzsGvMQEnCB7FCYsABb2ATOKxWLLgdtdu2rtXJDca59Oeu4NYfjUuEGhWwBCCjk4MXV8ZeXNIkryrFjCkqoCg");
            sb.Append("Bh5QfaEA6vF8QTSczNjY1ZUVzepq0JbJfFaaiPoB0GdAEAQAAAoAxEUAUhoBlsRBJZbgGlxKaYCmS4Gk5EDKaADAAQBLXPn34f4BnGqOR7LhlugAAAAldEVYdGNyZWF0");
            sb.Append("ZS1kYXRlADIwMDktMTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0");
            sb.Append("ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo0Mjo1MC0wNzowMBhJmOsAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8y");
            sb.Append("LjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMjoxNC0wNzowMNWL7EkAAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RF");
            sb.Append("WHRTb3VyY2VfVVJMAGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Configure2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Configure2_Reset()
        {
            _Configure2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Configure2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Configure2 = null;
        #endregion
        #region Image HourGlass
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku hourglass.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu HourGlass_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property HourGlass, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property HourGlass_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\hourglass.png
        /// </remarks>
        public static System.Drawing.Image HourGlass_Cached
        {
            get
            {
                if (_HourGlass == null) _HourGlass = HourGlass;
                return _HourGlass;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku hourglass.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image HourGlass_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HourGlass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property HourGlass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\hourglass.png
        /// </remarks>
        public static System.Drawing.Image HourGlass { get { return _ImageCreateFrom(_HourGlass_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru hourglass.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HourGlass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property HourGlass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\hourglass.png
        /// </remarks>
        public static System.Drawing.Image HourGlass_FromFile { get { return _ImageCreateFrom(_HourGlass_string, "hourglass.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru HourGlass
        /// </summary>
        /// <returns></returns>
        private static string _HourGlass_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(884);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAgRJREFUOE+lk01IVFEUx+/s0oLcNlCtysD82KSrNuHGVrVpRgbKImgGgz4Q+1j0HJTMxagryTCysaSUiJGcPkeUeVOB");
            sb.Append("Q2OBpTaC2qjzxjdX34fz8fC9f3ckBhdjSXPhcLmcc3733nP+hwAg+VheyZmLs4DTd6QCS5N0ycrJfG2TRK1OWT95XcAx26x+oHqC7iod40nxazspGSjY+uIswOJcLbvY");
            sb.Append("LNMbdxPg2lLgXEnc6ljHtU4FF9riOFEfRmHZCCWHn5fnBPS9mix68eY7z/XEceZmFFW2WRysDmFPBY/dJe9RUePD5YY+3nKuuygngLCFJY8DlFehCcCGCqgzgPSJ7RMw");
            sb.Append("xGeqFmlxbMZtKXz2kHFsOpcH6xB/F0RiiiVOM8AYjNiDoBZprsvG/B3gNiHqNiPmDkH+jI3F9pC20GJOzTtNOwMI90167LEZtP8b1HGkl1whJdy4T5q+ukNArOu8sTr8");
            sb.Append("Bel5IC3CUD8i+etekE7Z//0FRDsdRtyjIBUBjDQrZILVYJzZKNYXXIrw9ez2RXw4GNg7N9nvTwo+QBMBXWOMFUD2w6DDWJvrhd/byJ+ytOZuI1Pi0frWFbH3yU988EXg");
            sb.Append("CyjwjvzAwJAHPU8f4Xb7S+w/7hWZEktztvGPlO1Wbo2vuRKllbawnhFSYblfJ4feUlLsDZAjQ9tL+X8nMu9p/A0yc6wWTdWT+wAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property HourGlass_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void HourGlass_Reset()
        {
            _HourGlass = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití HourGlass_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _HourGlass = null;
        #endregion
        #region Image HourGlassGo
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku hourglass-go.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu HourGlassGo_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property HourGlassGo, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property HourGlassGo_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\hourglass-go.png
        /// </remarks>
        public static System.Drawing.Image HourGlassGo_Cached
        {
            get
            {
                if (_HourGlassGo == null) _HourGlassGo = HourGlassGo;
                return _HourGlassGo;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku hourglass-go.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image HourGlassGo_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HourGlassGo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property HourGlassGo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\hourglass-go.png
        /// </remarks>
        public static System.Drawing.Image HourGlassGo { get { return _ImageCreateFrom(_HourGlassGo_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru hourglass-go.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití HourGlassGo_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property HourGlassGo_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\FrxEditor\Pics\16\hourglass-go.png
        /// </remarks>
        public static System.Drawing.Image HourGlassGo_FromFile { get { return _ImageCreateFrom(_HourGlassGo_string, "hourglass-go.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru HourGlassGo
        /// </summary>
        /// <returns></returns>
        private static string _HourGlassGo_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1812);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAw1JREFUOMttk89PHGUcxj8zOwvMAgsFUqhQQIxB10B7JBaNB6FKjD96MKmJMfFQE62JRv8C09iLJw8emqhtUkNv1pu1jVUB22qstamgWMLP");
            sb.Append("0oVK2Z2dmXf2nfeHB92mNf2cv88nT77J48x9/m4DcAgYAwpAJ+BLmbhCVIjjwERRWURRaSOOg1khKmelTI69c6qSAHjAOb9r5766ljye34DreVhj0dUUnaTopOqmImkU");
            sb.Append("QTBQ2ioObBYXnltevPwyMArgWc9v5j+sMWiZYqRGS4USVXSSIoUkTSRGKQCcuuY7GW97zxsHRWXx95byPNXtFaLtdcLgb6KwRBSVECKkqlLchjzNXYNUeibwhvYcrAkc");
            sb.Append("ay3nr6dftzTY/X2tLo31GRwHImkollNEamlvzGAszK0GLBXDM2892//MPQKAb+bEl2BfGNzpOR1NHkFiKAtNvedwc7vK1cWSVUqfPjzRf4C7uCMA+OpKMOJgv+jKZwZ2");
            sb.Append("7ahHacsfN0KWNsLrSulX35548CL/4x5BjckLt6Ye6c6NGmO59OftqTf39z55+ORIJJXMSaNyx1+/Kmq3LvfBxXquCw6glXYAEiXp6XiUJE3jFz/p9+/bYPLHzcdzdc7k");
            sb.Append("QKff++nUBNYqpE6pKkV328MM94zy09K3/LZ20SRKtvzw/u3Qq4VPTm+c9rPO88N9zc6u1nqUkYw99hraGrTRGCzr5VWGevYRSuH+svJ9efiI2+YBnJgqnuneUTde2N1M");
            sb.Append("q58h4/5bWVvD8tZfpEahTEqqU4Jqhb27nyBMY/fS4vSWd+rctUK2oX08m3HJug7ZjEPGdUhUgtKKznwvymi0Ndwsr9DW1MXl1RlmFqZvScW4t3fts2P6gUFK3hAL7iA9");
            sb.Append("7TnyOQ+hqhy/8BHSSBIleaijwMjAOD8vTzMzd1YmlqfWP7SzHkCT2abNXiETzULkEEvNx4X37tpCwisLR3Bcn1/np3lpzb929EQ0W1vj06K4eUgUN8ekTApCVDrjOPCj");
            sb.Append("qOxGUYk4DowQFRH2pbnz8985B27UfdBZdY/Wnv8PO7u1SCWveOkAAAAldEVYdGNyZWF0ZS1kYXRlADIwMDktMTEtMTZUMjI6MTg6MTctMDc6MDBbAP7BAAAAJXRFWHRk");
            sb.Append("YXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA2OjUyOjU3LTA3OjAwl9vNqQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxMC0wMS0xMVQwNjo1Mjo1Ny0wNzowMOaGdRUAAABidEVY");
            sb.Append("dExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMy4wLyBvciBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8y");
            sb.Append("LjUvi4Y8ZQAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwNi0wMy0xMlQyMTo1Mzo0MC0wNzowMGV9NdQAAAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAA");
            sb.Append("G3RFWHRTb3VyY2UARkFNRkFNRkFNIFNpbGsgSWNvbnOCemT7AAAAM3RFWHRTb3VyY2VfVVJMAGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay/C");
            sb.Append("xA0NAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property HourGlassGo_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void HourGlassGo_Reset()
        {
            _HourGlassGo = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití HourGlassGo_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _HourGlassGo = null;
        #endregion
        #region Image Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link_Cached
        {
            get
            {
                if (_Link == null) _Link = Link;
                return _Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link { get { return _ImageCreateFrom(_Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link_FromFile { get { return _ImageCreateFrom(_Link_string, "link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Link
        /// </summary>
        /// <returns></returns>
        private static string _Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1120);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAABGdBTUEAAK/INwWK6QAAAAJiS0dEAACqjSMyAAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQ");
            sb.Append("AAAAEABcxq3DAAABCUlEQVQoz2P8z4AfMDHQXAELAwMDgz23TpZ0paTgvUcfwhgeChxVUnr+/mn7lWkHvzIwMP5nMGaTanEtDWf4yvCE4cD9X0/izFjYnzOcZdjd/azm");
            sb.Append("7C/G/wxGfk6Lkv41n/jsJsWsy/Cc4Q3Ds7+8uwK0T/Pvizu3iYmBgdGGn31f5feQL98jGGwYPBk8GL58/x7yuo2fndGGgYGFgeH3/ac/RHiZ1zOxdzJwMzAwfGVgYmde");
            sb.Append("z7z76Y/f9xkYWBgY/hx49kKtOuIfC+tLhlsM7AzyDOKsf0wemz178ecAAwPjfwZ1Zkld7vVSouzMDExvUhmeiqxnYP3599nrr4HPL9/8yzgIgpqgAgAhC16qmeXtNAAA");
            sb.Append("ACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNy0wNzowMFsA/sEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDY6NTM6MDgtMDc6MDDGsdga");
            sb.Append("AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUzOjA4LTA3OjAwt+xgpgAAAGJ0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNl");
            sb.Append("bnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIx");
            sb.Append("OjU0OjE0LTA3OjAwOw4E2gAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJjZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAz");
            sb.Append("dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Link_Reset()
        {
            _Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Link = null;
        #endregion
        #region Image Rel_dlen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlen.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dlen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dlen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dlen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlen.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlen_Cached
        {
            get
            {
                if (_Rel_dlen == null) _Rel_dlen = Rel_dlen;
                return _Rel_dlen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlen.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dlen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlen.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlen { get { return _ImageCreateFrom(_Rel_dlen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dlen.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlen.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlen_FromFile { get { return _ImageCreateFrom(_Rel_dlen_string, "rel_dlen.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dlen
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dlen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1112);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAq9JREFUOE+Nk2tIE2AUhg0Ss1Eu06mbMteWYxcvu7Cbo6Ur3SQv0zlGszncdLY5Zi7mAuc2SXMVSWaryOyyUpCijAgi");
            sb.Append("xIrUhEyD/lh/I+ivVEYX3zZFAmviC4ePj8N5v4fD+8XFrVNaCzUp4yjtGdPO/b6+t+Gd5KRtSbPRFII20awl2IBi9wFEB3KGBSmMO/z7jKGCqZgG6bbseIqNXis5Jv9W");
            sb.Append("322EqacekpZCMIYLpMxbwo91j0ygXeKuGP5XqfWZN/cYmL+VbSXQdNagNqADJ8CHKLz/5+W3FzH++TGofWyYTCZYrVY4HA64XC643e57K4a7deQQpYb2K69ZCMmJfcgN");
            sb.Append("SVE+qsX1d4MYeX8bIwthZJ1ixiZIriZvJapJKpqV9YV9VQjzQysGZvsRejOA0FykIifFnwOtVguDwQCz2QybzQan07lKENXeMN+af032o2XMCf9EAN0ve9D7KojgzGkE");
            sb.Append("p3uR7qHFJqAP5d2gBtngd0lROViLpgc2eCY60DkZgH+6C76pAEitVJSUlKCiogI6nQ5GoxEWi2WVgNrHOpPlZy5z/ULILxyEOqyBdqwOR540wTxuR+O4AynNmbEJoiYU");
            sb.Append("L1NL9tC/SvuVqLqrjww3oum5E/ZJV6SOI9lEhlgshkKhgEqlgkajgV6vXyVYy4GgVbzEcHIh6SuCZcKB1hkP2ud8aJ/3IUlP2lwOKr0a5Nr4YHt4cE55EFgI4uSHs9hR");
            sb.Append("lQIWiwUejweZTAalUomysrJ/cyBzK1DUUQrq4RxkGLMX7U9dOP/pCgjqXZvIgZ65WOxV4VB3NTimAiSp0+iEUuJrubcY24p2gkKhgE6ng8PhQCiMLFwu/5uD6C4IhUQR");
            sb.Append("VcN4ofaVL/MaRCsvkgVx8QmFhHOJCuL8hr9xrbk9n5iYkEcYTZWTlzYz8Af9Nz9EqOUqcAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dlen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dlen_Reset()
        {
            _Rel_dlen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dlen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dlen = null;
        #endregion
        #region Image Rel_dlet
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlet.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dlet_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dlet, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dlet_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlet.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlet_Cached
        {
            get
            {
                if (_Rel_dlet == null) _Rel_dlet = Rel_dlet;
                return _Rel_dlet;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlet.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dlet_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlet_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlet_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlet.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlet { get { return _ImageCreateFrom(_Rel_dlet_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dlet.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlet_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlet_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlet.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlet_FromFile { get { return _ImageCreateFrom(_Rel_dlet_string, "rel_dlet.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dlet
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dlet_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(932);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAihJREFUOE9jYKA1UFtmLKKy1Gi9yjyDYyTbpbLMwFJ9kcmTmC0J/xWn6/wnyQCVpYaFZosdfs+4OPX/3pfb/sv3a/1P");
            sb.Append("SEj4n56e/j83N/d/cXHx/7KysrUYhiqtMuZXXWy8zndVyP/5V+b8X35ryf/lNxf/l21XJ+wCleWGhuoLjO4nb0r/P+XspP/Tzk35P+08EANp6Qa1/yEhIf+jo6P/Jycn");
            sb.Append("/8/Kyvqfn5+PcIHqYqN0g3nWP3M25v9v2N/4v/VI2/+OE53/O092/e883vFfokIRtwuU5+ktkO/U+m/UZPnff07o/7QNWf8r9tf8rzva+L/heNP/+mON/8UK5P+7ubn9");
            sb.Append("9/Pz+x8WFvY/Li7uf0pKCsQF8v2a3bIN6v90Gkz+20x2/e+5OPB/yMaY/7E70/4n783+n7o3979Ihgz+MJCp0wiWrlT5ZDnJ+X/Amgig5tT/aQfz/2cfLQbikv9CCVL/");
            sb.Append("zc3N/9vb2//38PD4HxgY+D8iIgI1FsRy5ZTFsxTPW/Q7/k/Zn/u/4GTF//Lz9f/LL9T/548QIxwLIO8whjKwCcVIzdCqMPyff6zif+PNzv8tt3v+8waI/NfU1PxvaGj4");
            sb.Append("38rK6r+zs/N/Ly8vzHQASxj8QeLhknEKn7J3F/+f+Gzmf25PQeJcgJyy+D3FlbndBc7Y1Dr953Dk+y8tLf1fWVn5v7a29n8TE2CA29jgdgHMICljBlZ2a+4+TnuBCyTl");
            sb.Append("BWIVAwBn7/SzcUms8gAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dlet_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dlet_Reset()
        {
            _Rel_dlet = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dlet_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dlet = null;
        #endregion
        #region Image Rel_dlmn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlmn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dlmn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dlmn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dlmn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmn_Cached
        {
            get
            {
                if (_Rel_dlmn == null) _Rel_dlmn = Rel_dlmn;
                return _Rel_dlmn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlmn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dlmn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmn { get { return _ImageCreateFrom(_Rel_dlmn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dlmn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmn_FromFile { get { return _ImageCreateFrom(_Rel_dlmn_string, "rel_dlmn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dlmn
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dlmn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(972);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAkdJREFUOE9jYEAD4jny/JKZigfUs3V+oMvh5YvlKzKKZynaGxeZnU3pTPrvVObyH6RBbZmxiMpSo/Uq8wyO4TRAIkuB");
            sb.Append("VTpLOdSi0OZbfGvc/4S2+P8WOdb/VZYZWKovMnkSsyXhv+J0HbCBWIFovMxCpWj1v85Fbv8D64L/hzaG/dduNPpvttjh94yLU//vfbntv3y/Fm4DhMOkpkkHK/7RyzD5");
            sb.Append("b1Fp9193muV/31Uh/+dfmfN/+a0l/5ffXPxftl0dtwFCQVIsAp5iHorpml+0Zpv8T96U/n/K2Un/p52b8n/aeSAG0tINargNAPlLdbFRuv5cq185G/P/N+xv/N96pO1/");
            sb.Append("x4nO/50nu/53Hu/4L1GhiNsA5Xl6C+Q7tf4bNVn+958T+j9tQ9b/iv01/+uONv5vON70v/5Y43+xAnncBsj3a3bLNqj/02kw+W8z2fW/5+LA/yEbY/7H7kz7n7w3+3/q");
            sb.Append("3tz/Ihky+L0gXaseIlWh/NVykvP/gDURQM2p/9MO5v/PPloMxCX/hRKkcBsASwfGBebfVfJ1/lv0O/5P2Z/7v+Bkxf/y8/X/yy/U/+ePECMuHfjXBv7XzTL6r1Vh+D//");
            sb.Append("WMX/xpud/1tu9/znDRAhLh1Yldn/d6xx/y8fpfZfMk7hU/bu4v8Tn838z+0pSEQ6iFD/5FTr8d+nNei/doLBf35PcWVud4EzNrVO/zkc+fAHIigtcFsLmMkHqhzyrPf9");
            sb.Append("Z5hkBtYgZczAym7N3cdpL3CBqNzJpS/Aya7HvUrURuo7MRoA4g8ID0bjqicAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dlmn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dlmn_Reset()
        {
            _Rel_dlmn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dlmn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dlmn = null;
        #endregion
        #region Image Rel_dlmt
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlmt.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dlmt_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dlmt, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dlmt_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmt_Cached
        {
            get
            {
                if (_Rel_dlmt == null) _Rel_dlmt = Rel_dlmt;
                return _Rel_dlmt;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dlmt.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dlmt_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmt { get { return _ImageCreateFrom(_Rel_dlmt_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dlmt.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dlmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dlmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dlmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_dlmt_FromFile { get { return _ImageCreateFrom(_Rel_dlmt_string, "rel_dlmt.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dlmt
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dlmt_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(764);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAatJREFUOE9jYKA1UFtmLKKy1Gi9yjyDYyTbpbLMwFJ9kcmTmC0J/xWn6/wnyQCVpYaFZosdfs+4OPX/3pfb/sv3axFn");
            sb.Append("gNIqY37VxcbrfFeF/J9/Zc7/5beW/F9+c/F/2XZ1wgaoLDc0VF9gdD95U/r/KWcn/Z92bsr/aeeBGEhLN6jhN0B1sVG6wTzrnzkb8/837G/833qk7X/Hic7/nSe7/nce");
            sb.Append("7/gvUaGI2wDleXoL5Du1/hs1Wf73nxP6P21D1v+K/TX/6442/m843vS//ljjf7ECedwGyPdrdss2qP/TaTD5bzPZ9b/n4sD/IRtj/sfuTPufvDf7f+re3P8iGTL4vSBT");
            sb.Append("pxEsXanyyXKS8/+ANRFAzan/0w7m/88+WgzEJf+FEqQIB6JYrpyyeJbieYt+x/8p+3P/F5ys+F9+vv5/+YX6//wRYoQNACUUxlAGNqEYqRlaFYb/849V/G+82fm/5XbP");
            sb.Append("f94AEeIMgKU2/iDxcMk4hU/Zu4v/T3w28z+3pyBpBoAM4vcUV+Z2FzhjU+v0n8ORj3QDQIZIGTOwsltz93HaC1wgKS8QqxgATMe9fiGxlJwAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dlmt_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dlmt_Reset()
        {
            _Rel_dlmt = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dlmt_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dlmt = null;
        #endregion
        #region Image Rel_dren
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dren.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dren_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dren, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dren_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dren.png
        /// </remarks>
        public static System.Drawing.Image Rel_dren_Cached
        {
            get
            {
                if (_Rel_dren == null) _Rel_dren = Rel_dren;
                return _Rel_dren;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dren.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dren_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dren_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dren_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dren.png
        /// </remarks>
        public static System.Drawing.Image Rel_dren { get { return _ImageCreateFrom(_Rel_dren_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dren.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dren_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dren_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dren.png
        /// </remarks>
        public static System.Drawing.Image Rel_dren_FromFile { get { return _ImageCreateFrom(_Rel_dren_string, "rel_dren.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dren
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dren_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1104);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAqtJREFUOE+Nk1tIE2AYhhcUZqNcplM3Za4txw4edmAnR0tXukkepnOMZnO46WxzzFzMBc5tkuYqksxWkdlhpSCNMiKI");
            sb.Append("ECtSEzINurFuI+hWKqODb2sX0QFtP3z8N9/78F48H4GQwGM5eJ+zDtEfZbTRUhJYJxCYI0UzzJuC23mjwrSfgVLPXlhDTRB2iOcz7HQl2UXfsC6Ifp6HhntmsK6L3jJH");
            sb.Append("i2TStmKY+xrR2GuC9LDiE9XOqM+0526KQzweT9TtdsPpdMJms8FsNoM2wMHk+/u48PIcxJE9X7lBAeqDemi766DqKMNOI+t7emP2tTVb5BxnYWwpgrHXN3Dl1TAqx3XI");
            sb.Append("D8sgPbobBa0iUOvo33boKeE4wOVyRe12OywWC4xGI3Q6HaiBPIRfDCG8EJvYPzQ/CMtdGziXRKDb2B9IGrI6tZaycc0GmV46QrP9CM2dQP+zEHqf9iEwFUTbhAuFl+Vf");
            sb.Append("dkUEtl9hq9UaNZlM0Ov1qKqqQllZGcjtNPhnggjM9qB7OgjvVBda7thRPVwPQY8MtBAHjJGCq2s2SGvNRvOkE5ZJBw4+aIFuogGaiBaKs/vAC4iQE2Ct0gbYJ+MAg8EQ");
            sb.Append("1Wq1UKvVUCqVkEgkSDVT4Jg+Ehs3Wh67YpBm1NwyQDaoAsXL+Ej1sXTrepBiIKNz0Y/OBT/a57ywTjkhHSgB08WDsF2y8ocHFRUVUZVKBblcDj6fDzabja01aTj25hSC");
            sb.Append("SyG4ZrzgePnItwtQ7dMm5gFRsx1n3l2E46EbWabcZdqBPJR0lUPuUf7rgUKhiIpEInC5XDAYDFCpVGwu2QaFrxTEctLzFE0Gg2suwv7eWpT61KAbWMv/9SBZSVpMKiae");
            sb.Append("pggJcd/5TWJo/JWrNC3zCbGYJE7oIn9fSldQVpIKiONbCknJf4d/AJAZP0TgvdRNAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dren_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dren_Reset()
        {
            _Rel_dren = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dren_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dren = null;
        #endregion
        #region Image Rel_dret
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dret.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_dret_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_dret, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_dret_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dret.png
        /// </remarks>
        public static System.Drawing.Image Rel_dret_Cached
        {
            get
            {
                if (_Rel_dret == null) _Rel_dret = Rel_dret;
                return _Rel_dret;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_dret.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_dret_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dret_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dret_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dret.png
        /// </remarks>
        public static System.Drawing.Image Rel_dret { get { return _ImageCreateFrom(_Rel_dret_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_dret.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_dret_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_dret_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_dret.png
        /// </remarks>
        public static System.Drawing.Image Rel_dret_FromFile { get { return _ImageCreateFrom(_Rel_dret_string, "rel_dret.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_dret
        /// </summary>
        /// <returns></returns>
        private static string _Rel_dret_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(924);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAiJJREFUOE+1kV1oUgEUx+2hL6RcQ7R0y8y7mTrCq5LpBFuSqZDN5kzQRNBpaJe7MJxBTR197FYkrbUWDBvZJozuahFB");
            sb.Append("hEjQXIPKBb2sHnqJoNe9RdA/6yEYsY+KDhzOy//8+HEOh/M/isirK8SY5n7zuJb/V3zpzRb4HwUhv6P7SIyrDctCkskkm0gkQFEUotEogsEgJDklSp8fY/jNDewp7PtK");
            sb.Append("jJEn/8ik8aIcxfkCiu/u4vbbERyacKOpoJ3cOaHl/QaiaZqNxWIIhULw+Xxwu90QZ5ox9HoQQ9Va1+bgqwGEHkYhH9V8IIokuaLN1pQUzEw/mNlL6H/B4PzzC8iUszgx");
            sb.Append("RUOdb/3SVNBEf0HC4TAbCATg8XjgdDphtVoh6JYgXckiM9OH3uksUuUziDyI4fBIJzR9BkgYJWT53aNLmvCPN6CrRCFUiuPYkwjcU37YCy6Yrh9AS0aHxoz8mySnuPwT");
            sb.Append("4PV6WZfLBZvNBrPZDL1ej/qgCPHpU7VOIPKMrkG60H7PC8OABeLTxEJD766OZe/A8wrQM5dGTzWN7tkUwmUKe3NtEMakVQG1XbZo2eFwsBaLBUajESRJQqFQYFM7H+fe");
            sb.Append("X0F2ngFdSUGZIlHvFw2v6eSsW/EDPwJc+xZc+3QL8acJbAvsWOAdER5dctFkMrE6nQ4qlQoymQxisRgb2jbDdHY/uAfrXvLswsXKq1HYaK6bW9/KvSrSctauJv9Pme+f");
            sb.Append("WfSzAUitPQAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_dret_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_dret_Reset()
        {
            _Rel_dret = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_dret_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_dret = null;
        #endregion
        #region Image Rel_drmn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_drmn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_drmn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_drmn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_drmn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmn_Cached
        {
            get
            {
                if (_Rel_drmn == null) _Rel_drmn = Rel_drmn;
                return _Rel_drmn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_drmn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_drmn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_drmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_drmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmn { get { return _ImageCreateFrom(_Rel_drmn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_drmn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_drmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_drmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmn_FromFile { get { return _ImageCreateFrom(_Rel_drmn_string, "rel_drmn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_drmn
        /// </summary>
        /// <returns></returns>
        private static string _Rel_drmn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(976);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAklJREFUOE+Nk11MkgEUhmmrmbGCDFFB9/kF8U1ERGAEwiKxUracouJYmTB/0AAHaVPaRMCFSbVYZlTL7IfSzbWVrbW1");
            sb.Append("xqiWmFumbd1Yt62tW1fZ+vGNumptIGc7OzfnPNs5ew6NlkZQdtG3vKPk0xwHwUijnUbjT0ji/DvSe4JJGevPgK5vH9qDrZD1KBZybKSW7SQ3pASRl0RofmgBdUv+gT8p");
            sb.Append("USkdaliGzTAHWqA8pvnKtfGMubbCTUkhREiI6KdHuPzmIhSRvT+K/VIY/U0wDDagsucAdh6mfmWb828mBRScojC1HMHUu9u4/nYcNdONKAmroDyxB+IuObgN5M8dTZxw");
            sb.Append("UgDXJ0D49RjCi4lM1LGFUbQ96ITwqhxkZ9Fnpp5dnVXP2ZgUkOsmEZwbQXD+NEZeBhF4MQxfzA/HjBOl18q/74pIO1Meke0i4I374ZsbwuCsH+7YAKz3bagdN0I6pAIR");
            sb.Append("FII3Ib6RFMLqykdHtBttUTuOPLaicaYZ+ogBmgv7IfLJUeCj1ohQ0ZmkgCwLB/bZ44nshfWZMwHpQN1dE1SjleC4eV+4Hqox5QoMExv9S170L3rhmnejPdYNZagCfKcI");
            sb.Append("Mtfu1XU92FrHwsn3Z+FfDsIZd0PoLkOJTYpajyE9D+j67Tj/8QrsT3qR11K4QhwSoGKgCuV92vQ82FyxDRqPDvQq5iuGPodXbJHgYKAeOk81SBO1sq4HmVrmUoaafo4j");
            sb.Append("o/31vaxVAb23Zo0w8J/T1UxFWh/5b1O2hrOaIaZPbyllZv4//BvrnwgP6VvaegAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_drmn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_drmn_Reset()
        {
            _Rel_drmn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_drmn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_drmn = null;
        #endregion
        #region Image Rel_drmt
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_drmt.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_drmt_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_drmt, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_drmt_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmt_Cached
        {
            get
            {
                if (_Rel_drmt == null) _Rel_drmt = Rel_drmt;
                return _Rel_drmt;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_drmt.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_drmt_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_drmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_drmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmt { get { return _ImageCreateFrom(_Rel_drmt_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_drmt.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_drmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_drmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_drmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_drmt_FromFile { get { return _ImageCreateFrom(_Rel_drmt_string, "rel_drmt.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_drmt
        /// </summary>
        /// <returns></returns>
        private static string _Rel_drmt_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(776);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAbNJREFUOE9jYKAFUJlncExlqdF6tWXGImSZrzhd53/MloT/6otMnqgsM7Ak2RD5fq3/e19u+z/j4tT/ZosdfqssNSwk");
            sb.Append("yRDZdvX/y28u/r/81pL/86/M+e+7KuS/6mLjdUqrjPmJMki6Qe3/tHNT/k87D8RAesrZSf+TN6X/V19gdF9luaEhQUMkKhT/dx7v+N95sut/x4nO/61H2v437G/8n7Mx");
            sb.Append("/7/BPOufqouN0vEaIlYg/7/+WOP/huNN/+uONv6v2F/zP21D1n//OaH/jZos/8t3av1Xnqe3AKchIhky/1P35v5P3pv9P3Zn2v+QjTH/PRcH/reZ7Ppfp8Hkv2yD+j/5");
            sb.Append("fs1unAYIJUj9zz5aAsTF/9MO5gMNSf0fsCbiv+Uk5//SlSqfZOo0gvF6gT9C7H/5hfr/5efr/xecrPifsj/3v0W/43/xLMXzYrlyygQDkTdA5H/L7Z7/jTc7/+cfq/iv");
            sb.Append("VWH4XyhGagZjKAMbQc0gBdyegv8nPpv5P3t38X/JOIVP/EHi4URphCnicOT7b1Pr9J/bXeAMv6c4YSejm85pL3CB3Zq7T8qYgZUkm8lRDAD6371+qrtJ1QAAAABJRU5E");
            sb.Append("rkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_drmt_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_drmt_Reset()
        {
            _Rel_drmt = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_drmt_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_drmt = null;
        #endregion
        #region Image Rel_slen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slen.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_slen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_slen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_slen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slen.png
        /// </remarks>
        public static System.Drawing.Image Rel_slen_Cached
        {
            get
            {
                if (_Rel_slen == null) _Rel_slen = Rel_slen;
                return _Rel_slen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slen.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_slen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slen.png
        /// </remarks>
        public static System.Drawing.Image Rel_slen { get { return _ImageCreateFrom(_Rel_slen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_slen.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slen.png
        /// </remarks>
        public static System.Drawing.Image Rel_slen_FromFile { get { return _ImageCreateFrom(_Rel_slen_string, "rel_slen.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_slen
        /// </summary>
        /// <returns></returns>
        private static string _Rel_slen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1112);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAArFJREFUOE+Nk31IE1AUxQ0SKwnD1GljDdvKdKms2b5czLlcm+jm2pyb0znccrZpW47miqbTNB1GKzMLNE2nJlKUJYKI");
            sb.Append("WJKakGkQgfVvBP0rldGHp+aIwlp44PJ4XO55Py7nhYSsE4FbERHHOfEo4Yjl8/ref+8xLOsmAsvMZ8iq5kurPcgsdMA/sE8zEEUt6L9Hze+aCWoQyzGHEtPN+Wz5qU+6");
            sb.Append("qkaU2C+ALasAVTPASVD3vi1qGEG8/Pqa4T8VzSjp2cPVfheqqyAvq0G+uQ40WR2YBt/Xa6MvMPrqPcg5Xuj1ephMJlRWVsJut8PhcNxdM9yZomon0hXfUrLKwVacQbKq");
            sb.Append("Hbmnh9A5/hJ9U6/hm1oCSdwUnCAy6djmHQkScfxh04ckTQcMTQ/QOjyPtofPf9bC2kkUuqFUKqHVamEwGGA2m2G1WgMEfu0t8JlStTe/VFwchrt7Eo19T9B8+yk8g3No");
            sb.Append("HpxFLN8ZnICi6rpFlnhwUFEPma0TZU334bwxiZruabh7Z1HbM4MYrg0ikQhSqRQqlQo6nQ5GozFAQM71tpCy3KsHpG7wSq5CctIH5dlhFNePwdA8geOeCUQxy4MT+E2I");
            sb.Append("GS7lrgznR05RK/Icd1B8fgxlLY9huTwNi3cakXQ9WCwW+Hw+xGIx5HI51Gp1gOBXDhi5thWqwAq21gujZxK2tjlUdyygunMREcnqjeVAZnQhWWRGUrYT1tYZ1PUvoWHw");
            sb.Append("Dbbvz0NiYiLodDq4XC6EQiGys7P/zgFX4YBAcw5kZiHiDumWLS3juDLyDuFUyQZywFIvZxa6kGNoBE2gRwRVQgmnHn3GK3BhC1kAIpEICoUCGo2GtLQ08Hi83znw7yJ8");
            sb.Append("dzqTzJBPSfS1q/Ss0sCLDEZoGCn90lYSfzHoX/izsY2QujWMkDIUTeWtbGTgB603TMdLGAD0AAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_slen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_slen_Reset()
        {
            _Rel_slen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_slen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_slen = null;
        #endregion
        #region Image Rel_slet
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slet.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_slet_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_slet, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_slet_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slet.png
        /// </remarks>
        public static System.Drawing.Image Rel_slet_Cached
        {
            get
            {
                if (_Rel_slet == null) _Rel_slet = Rel_slet;
                return _Rel_slet;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slet.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_slet_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slet_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slet_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slet.png
        /// </remarks>
        public static System.Drawing.Image Rel_slet { get { return _ImageCreateFrom(_Rel_slet_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_slet.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slet_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slet_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slet.png
        /// </remarks>
        public static System.Drawing.Image Rel_slet_FromFile { get { return _ImageCreateFrom(_Rel_slet_string, "rel_slet.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_slet
        /// </summary>
        /// <returns></returns>
        private static string _Rel_slet_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(928);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAiZJREFUOE+1k19oUnEUx/fSP0YIY6zCROretcyibjNtdkFEMpVms/nnis6EazM005CcBa3bWqgYWbZokLg15yajf9YY");
            sb.Append("jDGkka5B5YIIVg+9RNDr3iLoWyz6x1ibD/3gcF4O3/M553x/VVX/+22zDtWSluwD0pQuVdyLtA41NTADH+zdo9hiuIWKBEgme1rKZr7cHHuFsTefIDycgNPphNvths/n");
            sb.Append("QzAYRCgUurdIdKtphFdvztxvPjOC1MRrDE69RWZqDgJNZHkCkhmmGqz979nIIyTzL9Dz+OX3KC9kvoqD0WiEzWYDy7LweDzw+/2/CeotGfcee/rzySt5cH0FXB58iujw");
            sb.Append("M8RyM4jmprFREV6agDCn+4XaGPa2duFIIIX2yEOEewvo7CuCG5jGhTsl1MkDUKvV0Ov1MJvNcDgccLlcPwiEzYm44CD3daeeA33sBrSnMjCey6OtaxxsdBLHY5OolZ74");
            sb.Append("9w42Kztb+cqz8032JFpCd9F2aRzt8SfwXivCmyiihnJCJpNBoVBAo9HAYDCAYZi/r1An9xEbpJ7yflsCrlgBgZ4ZdNwuoyM1C94uZvkrLMwjNq2u2W3v3aELw58s4WJ2");
            sb.Append("Dt25d1i/vQUikQgURUEul0OlUkGn0y32wU9j8ERHLZv2Oea98QlcH/2IalK7QoI/rMUjtUQ1eeg5bTmPtUIl+Hw+CIKAWCyGRCIBTdNLE/zSaWxctUZw4Oo6gWK2or+w");
            sb.Append("0uJvx9P/DeNNlfIAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_slet_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_slet_Reset()
        {
            _Rel_slet = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_slet_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_slet = null;
        #endregion
        #region Image Rel_slmn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slmn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_slmn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_slmn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_slmn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmn_Cached
        {
            get
            {
                if (_Rel_slmn == null) _Rel_slmn = Rel_slmn;
                return _Rel_slmn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slmn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_slmn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmn { get { return _ImageCreateFrom(_Rel_slmn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_slmn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmn_FromFile { get { return _ImageCreateFrom(_Rel_slmn_string, "rel_slmn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_slmn
        /// </summary>
        /// <returns></returns>
        private static string _Rel_slmn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(976);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAklJREFUOE9jYEAD4lY5/JKWmQfUXbJ/oMvh5YuZ5zOKm2fZG/sXnU0q7/zvFFX2H6RBLXKZiEr40vUqofOO4TRAwjKL");
            sb.Append("Vdo6K9QisPBbXFHr//jitv8W/jn/VSKXWapHLHoS07Llv2LgdLCBWIGocfxCJavov84RRf8D0+r+h2Y1/tf2b/xvlrz499RtF/9vu/byv7xPP24DhPXCpkkbBv/Rc834");
            sb.Append("bxFc+V83bNp/39JV/+fsvvJ/yaFb/xcfuvlf1qMdtwFCWkEsAuqeHoq26V+0Imf/T27f9H/SxrP/p2w+B8TnwbS0cwNuA0D+Ug1fnK4fPfdXTs/G/w3z9/9vXXLkf8fy");
            sb.Append("E/87V5z837Hi+H8J+wrcBiiHzVsg79n53yi46b9/wZz/ae0b/lfM2P+/bv7R/w2Ljv+vX3jsv5hVAW4D5H37u2VdG/7p+DX8t4mf/N8zb/H/kKqN/2Obdv5P7tj7P7Vz");
            sb.Append("738Rswz8XpB2qA2Rcqj4ahkz6X9A2Zr/sc07/6d1H/yfPeHo/+z+o/+FDBNwGwBLB8a+Bd9VHPP/W0T3/0/p3P+/YMrJ/+Wzz/8vn3PhP79uBHHpwD+l9r+uW9Z/La+K");
            sb.Append("//mTjv1vXHrzf8uK2/95NQKISwdWwWX/HSNr/subRf2XNI37lN29+//ELc/+c6t4EpEOzCM+OUXV/vdJbv2v7Zjwn1/FU5lbxf2MTXjtfw55R/yBCEoL3HLWZvLGgYc8");
            sb.Append("E+r/GbomQTQYG7Oyy1r3ccraXyAqd3KJ63Oyi+utElWx+U6MBgCSDxWSfMeUtAAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_slmn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_slmn_Reset()
        {
            _Rel_slmn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_slmn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_slmn = null;
        #endregion
        #region Image Rel_slmt
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slmt.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_slmt_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_slmt, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_slmt_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmt_Cached
        {
            get
            {
                if (_Rel_slmt == null) _Rel_slmt = Rel_slmt;
                return _Rel_slmt;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_slmt.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_slmt_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmt { get { return _ImageCreateFrom(_Rel_slmt_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_slmt.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_slmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_slmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_slmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_slmt_FromFile { get { return _ImageCreateFrom(_Rel_slmt_string, "rel_slmt.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_slmt
        /// </summary>
        /// <returns></returns>
        private static string _Rel_slmt_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(764);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAaxJREFUOE9jYKA1UItcJqISvnS9Sui8YyTbpRK5zFI9YtGTmJYt/xUDp/8nyQCViKWFZsmLf0/ddvH/tmsv/8v79BNn");
            sb.Append("gFLoKn7VsMXrfEtX/Z+z+8r/JYdu/V986OZ/WY92wgaoRCw3VI9ccD+5fdP/SRvP/p+y+RwQnwfT0s4N+A1QDV+cbhAz72dOz8b/DfP3/29dcuR/x/IT/ztXnPzfseL4");
            sb.Append("fwn7CtwGKIfNWyDv2fnfKLjpv3/BnP9p7Rv+V8zY/79u/tH/DYuO/69feOy/mFUBbgPkffu7ZV0b/un4Nfy3iZ/83zNv8f+Qqo3/Y5t2/k/u2Ps/tXPvfxGzDPxekHGs");
            sb.Append("C5Z2rPxkGTPpf0DZmv+xzTv/p3Uf/J894ej/7P6j/4UMEwgHophVrrK4WdZ5i+j+/ymd+/8XTDn5v3z2+f/lcy7859eNIGwAOKFoh7IJ6cfM0PKq+J8/6dj/xqU3/7es");
            sb.Append("uP2fVyOASAOgyY1fMyhc0jTuU3b37v8Ttzz7z63iSZoBIHP4VTyVuVXcz9iE1/7nkHck3QCwY4yNWdllrfs4Ze0vkJQXiFUMAKyrx9jFNfhNAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_slmt_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_slmt_Reset()
        {
            _Rel_slmt = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_slmt_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_slmt = null;
        #endregion
        #region Image Rel_sren
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_sren.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_sren_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_sren, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_sren_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sren.png
        /// </remarks>
        public static System.Drawing.Image Rel_sren_Cached
        {
            get
            {
                if (_Rel_sren == null) _Rel_sren = Rel_sren;
                return _Rel_sren;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_sren.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_sren_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_sren_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_sren_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sren.png
        /// </remarks>
        public static System.Drawing.Image Rel_sren { get { return _ImageCreateFrom(_Rel_sren_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_sren.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_sren_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_sren_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sren.png
        /// </remarks>
        public static System.Drawing.Image Rel_sren_FromFile { get { return _ImageCreateFrom(_Rel_sren_string, "rel_sren.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_sren
        /// </summary>
        /// <returns></returns>
        private static string _Rel_sren_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1108);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAq1JREFUOE+Nk1tMEgAYhWmrmblmM68xYgZlSuoI4yYNkSRgChKIIIpMSAw0SBZSC0XTlNmizKxN0xQ152JlOTfnnOVS");
            sb.Append("c8u0rbVZr62tV1fZungqHlqXafzbv//lnLPz8P0EQgiTdMT6KYFz4mEctzIyBDmBQC3onqUWDtzdpx2M/mnILnKirMYLhrx6IY5l4ceybJs2DEpUXEdx4yiSNH1vqNpB");
            sb.Append("DlteiVLHBeirm8BWnPpIzLQUxHMsW4IhTqcz4HA4UFVVBbPZDIPBAHKuD2Mv3+Ha2HMwjf4vNHk9Ciz1UJTXQqipxh6u7lsMo7R33RYkcTP808von36FrokXyDs9jFR1");
            sb.Append("B9jKM0jLqQCRrvy6M03dEQyw2WwBi8UCo9EInU4HlUoFotCD9gfPfuxi8LaNLMDYfB8p2k4kHja/35EkEUelHNu8boN4vgstQ3PwDs2j5fYTNPU/hqdnCpUXR5Cuu/l5");
            sb.Append("b6Hf/MtsMpkCer0earUaMpkMIpEIsVw76npn4embQ23PDFw3plDefA9yexcOKhtAlnhBUXffWrdBNLMCx72TMLZMoqRhHKqzI5Cc9INXehUHZB6Qcjxr5DxfazBAo9EE");
            sb.Append("FAoFxGIx+Hw+WCwWougGWH0zsF6eQXnrI5ScH0e+8w44xW3YleX6QMxyqzbkIDJVg5quJdR0LsLePg+TdwpsnQ9UgQ2MPPvqHxxIpdKAUCgEl8sFnU5HcnIytu/PR+PQ");
            sb.Append("a9QPLMPWNosUqQupIgvkJndoHERQJbgy+hbW1gkkHNKvkJlFEGjPgat0/ssBj8cLZGRkgEajgUKhgEgkYitZAF6hGxHUo08jqRIKTWBArrEJ2UVuJLI0K//lIJzEXwoj");
            sb.Append("ZV4iMBhB3uk5ZZAY6tbIDMV0xO5MZkgf+bsohspbDYtLG94Wlx7+t/k7i6ZMxwqULNMAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_sren_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_sren_Reset()
        {
            _Rel_sren = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_sren_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_sren = null;
        #endregion
        #region Image Rel_sret
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_sret.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_sret_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_sret, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_sret_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sret.png
        /// </remarks>
        public static System.Drawing.Image Rel_sret_Cached
        {
            get
            {
                if (_Rel_sret == null) _Rel_sret = Rel_sret;
                return _Rel_sret;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_sret.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_sret_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_sret_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_sret_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sret.png
        /// </remarks>
        public static System.Drawing.Image Rel_sret { get { return _ImageCreateFrom(_Rel_sret_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_sret.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_sret_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_sret_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_sret.png
        /// </remarks>
        public static System.Drawing.Image Rel_sret_FromFile { get { return _ImageCreateFrom(_Rel_sret_string, "rel_sret.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_sret
        /// </summary>
        /// <returns></returns>
        private static string _Rel_sret_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(924);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAiNJREFUOE+1kV1oUgEUx33pixHCGKswkfKuZRZ1m2m7CSKSqTSbzY8rOhOuzdBMQ3IWtGwtVIwsWzRI3Jpzk9Fts8Zg");
            sb.Append("jCGNdA0qF0Sweuglgl73FkH/ag/BiH1UdOBwXv7nx49zOJz/UYQpUyYsuZFd1sGav+LvMNyDvWsM9XT/R8I62LgiJBQKscFgED6fD263G06nE4LjSYy//Yy7468hZbJf");
            sb.Append("CTp3/o9M+JoostPzGJh+h/TkGzRdGEadOftop2mY+xvI7/ezHo8HDMPAZrPBaDSCp4qg+8mrH11ZnKnCSzDRx6i39n0g6CFyVZutijBi+RnE87OIDT3H9YFniPQWcfZG");
            sb.Append("AQfsmS91lqz7F8TlcrEOhwNmsxl6vR5qtRq1VABXHpQR6Z9BR28J4Z4i2qKjOBFI42BLJwTaOITmTN+yJjXSMzgdnwITm0Jr5wSMlwrQnstCfuoO9uoj4B+NfBM0JROL");
            sb.Append("AJqmWYPBAI1GA4VCAZlMhmrSCW+yBO+tEtoST9F6bQLNoYdotKfAU15c2K7saFnxDtx9NNrTc2i/X0GgexaueBGHbUlskXoqtZRPuGRZp9OxKpUKFEWBJEmIRCJs3t2M");
            sb.Append("rvx7XM3Nw58qY48ujOr99h6O2LR+1Q/8DFQRWtwe+wRvYhLbDjkWuKKTlmUX5XI5K5FIIBaLIRQKwePxsFGghNxyGVXEsRdcQrtUeS0Km/iKuQ38Izc5DQ3r1pL/p8x3");
            sb.Append("tz3/DWP2BXkAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_sret_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_sret_Reset()
        {
            _Rel_sret = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_sret_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_sret = null;
        #endregion
        #region Image Rel_srmn
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_srmn.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_srmn_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_srmn, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_srmn_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmn_Cached
        {
            get
            {
                if (_Rel_srmn == null) _Rel_srmn = Rel_srmn;
                return _Rel_srmn;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_srmn.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_srmn_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_srmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_srmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmn { get { return _ImageCreateFrom(_Rel_srmn_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_srmn.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_srmn_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_srmn_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmn.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmn_FromFile { get { return _ImageCreateFrom(_Rel_srmn_string, "rel_srmn.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_srmn
        /// </summary>
        /// <returns></returns>
        private static string _Rel_srmn_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(976);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAktJREFUOE+Nk21I0wEQhxcUZhILU6eNNcx/LWab2GhvLnSa5UKba27uRd1wpraNXIt0RdPNtG0sWi2zQNN0akOCWokg");
            sb.Append("IqvRZkKmQQTW1wj6KpXRi7/KTxFMd3Dcl7sH7niOREogGEdM37IEp59ShGZyAu0kEqEYiBHVow/3qcfS/g4Ua1pR3+YBR2qdp/CMhRm8lk3rgrJlt1HTNQGGavgDoR4T");
            sb.Append("8KVm6M5dQZ21G3zZ2a/UAqMiU2DcEhdCL/dh8u0n3Jp8Da4h8CNX6oTC6ISssR0lKiv2CLW/0jm6obgAWpkLgcgSRiLv0D/9BhXnx8FS9oIvvwB2aTOo+fKfO9nK3rgA");
            sb.Append("aokDPU9e/cmFteoPzcPgegymug/Zh5s+72BIylKZJzfHBWQW2uAOzsITnIP7/gt0jzyHYzAM89UQ8rR3v++tDjSte8QMoQUdQzE4hmfRPhiF7U4Yja5HkFr6cVDeCbrE");
            sb.Append("gxzlwL24kDRuM055ZmBwz6C2cwpVF0OQnAlApLuJAyccoJU6VukVPm9cQGq+HiZfFKbrUTR6n6H28hQqWx9AUOPHriLbF2qRvWrdFcgsFdr6F9HWtwBLzxwaPGHwtT4Q");
            sb.Append("4hZwKiwrG3qwfX8luoLv4RxdQos/BuZxG1hHjZA22BPzIIWQ4MbER5i808g6VLdM52ogVl+CUN6amAdb6WKIqu1IIY69JBOSnFyxHuWGbhRr7MjmqZY39CCZVriYRCu4");
            sb.Append("RuJw1nzPL62HRN+xSufIIim7C7gJfeS/TemEaCWJwh7fRslL/n/4N+csFZK95jyMAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_srmn_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_srmn_Reset()
        {
            _Rel_srmn = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_srmn_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_srmn = null;
        #endregion
        #region Image Rel_srmt
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_srmt.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Rel_srmt_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Rel_srmt, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Rel_srmt_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmt_Cached
        {
            get
            {
                if (_Rel_srmt == null) _Rel_srmt = Rel_srmt;
                return _Rel_srmt;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku rel_srmt.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Rel_srmt_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_srmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_srmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmt { get { return _ImageCreateFrom(_Rel_srmt_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru rel_srmt.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Rel_srmt_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Rel_srmt_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Support\pic\16\rel_srmt.png
        /// </remarks>
        public static System.Drawing.Image Rel_srmt_FromFile { get { return _ImageCreateFrom(_Rel_srmt_string, "rel_srmt.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Rel_srmt
        /// </summary>
        /// <returns></returns>
        private static string _Rel_srmt_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(776);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3");
            sb.Append("YXJlAFBhaW50Lk5FVCB2My41LjEwMPRyoQAAAbVJREFUOE9jYKAFUAmdd0wlfOl6tchlImSZrxg4/X9My5b/6hGLnqhELrMk2RB5n/7/2669/D9128X/ZsmLf6tELC0k");
            sb.Append("yRBZj/b/iw/d/L/k0K3/c3Zf+e9buuq/atjidUqhq/iJMkjaueH/lM3ngPg8mJ608ez/5PZN/9UjF9xXiVhuSNAQCfuK/x0rjv/vXHHyf8fyE/9blxz53zB///+cno3/");
            sb.Append("DWLm/VQNX5yO1xAxq4L/9QuP/W9YdPx/3fyj/ytm7P+f1r7hv3/BnP9GwU3/5T07/yuHzVuA0xARs4z/qZ17/yd37P0f27Tzf0jVxv+eeYv/28RP/q/j1/Bf1rXhn7xv");
            sb.Append("fzdOA4QME/5n9x/9nz3h6P+07oP/Y5t3/g8oW/PfMmbSf2nHyk8yjnXBeL3Arxvxv3zOhf/ls8//L5hy8n9K5/7/FtH9/8XNss6LWeUqEwxEXo2A/y0rbv9vXHrzf/6k");
            sb.Append("Y/+1vCr+C+nHzGDQDmUjqBmkgFvF8//ELc/+Z3fv/i9pGveJXzMonCiNMEUc8o7/bcJr/3OruJ/hV/Ek7GR00zll7S+wy1r3MRgbs5JkMzmKARLSx9jlua2vAAAAAElF");
            sb.Append("TkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Rel_srmt_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Rel_srmt_Reset()
        {
            _Rel_srmt = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Rel_srmt_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Rel_srmt = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                string dirName = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), "PicLibrary\\SchedulerPic16");
                if (!System.IO.Directory.Exists(dirName))
                    System.IO.Directory.CreateDirectory(dirName);
                return dirName;
            }
        }
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
